This is interesting. Can we use it to define aliases within the same class?

trait IterableOps[+A, +CC[_], +C] {

  def concat[B >: A](other: IterableOnce[B]): CC[B]

  export this.{concat => ++}

}

Note that a difference with the examples you mentioned is that class members can be refined, in which case the alias should be refined accordingly:

trait X[+A] extends IterableOps[A, Seq, List[A]] {

  def concat[B >: A](other: IterableOnce[B]): List[B] = ... // note that return type is `List[B]` instead of the inherited `Seq[B]`

}

Note that a difference with the examples you mentioned is that class members can be refined, in which case the alias should be refined accordingly

No, export is not made for that. I think what you are looking for in this use case is @alpha (#5975).

Should we have a Contributors thread to discuss the proposal, independently of its implementation?

In the meantime:

Type members are aliased by type definitions, and term members are aliased by method definitions. Export aliases copy the type and value parameters of the members they refer to.

So, exports basically copy members. IIUC that means we cannot use export to re-export towers of implicits with decreasing priorities in a hierarchy of classes (the XYZLowPriorityImplicits pattern), as the exports will all end up in the same level of priority, even when the imported members had different levels of priority. This means that it is impossible to use export to replace the use of package object with extends that use the LowPriorityImplicits pattern. Now, that pattern is the only strong reason that we could not already replace all package objects by top-level definitions (albeit with more boilerplate than with export). So IIUC export does not actually solve the loss of API design expressivity incurred by dropping package object ... extends.

@srjd Yes, I was going to open a thread on contributors.

Regarding implicits, we fortunately will have better ways now to prioritze than by location of original definition.: #6071 (comment).

Proposal for error test cases:

class Foo {
  lazy foo : Foo = new Foo
  export foo._
}

class Foo {
  lazy bar: Bar = new Bar
  export bar._
}
class Bar {
  lazy foo: Foo = new Foo
  export foo._
}